package com.bawei.module_live.ui

import com.bawei.lib_common.entity.ResponseEntity
import com.bawei.lib_net.RetrofitFactory
import com.bawei.module_live.data.*
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.flow.catch
import okhttp3.ResponseBody
import retrofit2.Response

/**
 * 直播间模块 - 数据仓库层
 * 
 * Repository负责数据获取和缓存管理，包括：
 * - 网络数据获取
 * - 本地数据缓存
 * - 数据转换和处理
 * - 错误处理
 * 
 * 作为ViewModel和网络层之间的桥梁，提供统一的数据访问接口
 */
class LiveRepository {
    
    // ==================== 网络接口实例 ====================
    
    /**
     * 直播间网络接口实例
     */
    private val liveApi: LiveApi = RetrofitFactory.getRetrofitFactory().create(LiveApi::class.java)
    
    // ==================== 直播列表相关方法 ====================
    
    /**
     * 获取直播列表
     * @param page 页码
     * @param pageSize 每页数量
     * @return 直播列表数据流
     */
    fun getLiveList(page: Int, pageSize: Int) = flow {
        emit(liveApi.getLiveList(page, pageSize))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, emptyList(), e.message ?: "获取直播列表失败"))
        }
    
    /**
     * 获取直播间列表
     * @return 直播间列表数据流
     */
    fun getLiveRoomList() = flow {
        emit(liveApi.getLiveRoomList())
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, emptyList(), e.message ?: "获取直播间列表失败"))
        }
    
    // ==================== 直播间管理方法 ====================
    
    /**
     * 进入直播间
     * @param roomId 直播间ID
     * @return 操作结果数据流
     */
    fun enterLiveRoom(roomId: String) = flow {
        emit(liveApi.enterLiveRoom(roomId))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, false, e.message ?: "进入直播间失败"))
        }
    
    /**
     * 退出直播间
     * @param roomId 直播间ID
     * @return 操作结果数据流
     */
    fun exitLiveRoom(roomId: String) = flow {
        emit(liveApi.exitLiveRoom(roomId))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, false, e.message ?: "退出直播间失败"))
        }
    
    /**
     * 获取直播间用户列表
     * @param roomId 直播间ID
     * @return 用户列表数据流
     */
    fun getLiveRoomUsers(roomId: String) = flow {
        emit(liveApi.getLiveRoomUsers(roomId))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, emptyList(), e.message ?: "获取直播间用户列表失败"))
        }
    
    // ==================== 礼物系统方法 ====================
    
    /**
     * 获取礼物列表
     * @return 礼物列表数据流
     */
    fun getGiftList() = flow {
        emit(liveApi.getGiftList())
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, emptyList(), e.message ?: "获取礼物列表失败"))
        }
    
    /**
     * 发送礼物
     * @param senderId 发送者ID
     * @param receiverId 接收者ID
     * @param giftId 礼物ID
     * @param count 礼物数量
     * @param roomId 直播间ID
     * @return 操作结果数据流
     */
    fun sendGift(
        senderId: Int,
        receiverId: Int,
        giftId: Int,
        count: Int,
        roomId: String
    ) = flow {
        emit(liveApi.sendGift(senderId, receiverId, giftId, count, roomId))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, false, e.message ?: "发送礼物失败"))
        }
    
    /**
     * 发送房间礼物（新版本）
     * @param request 礼物请求体
     * @return 操作结果数据流
     */
    fun sendRoomGift(request: SendGiftRequest) = flow {
        emit(liveApi.sendRoomGift(request))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, false, e.message ?: "发送房间礼物失败"))
        }
    
    /**
     * 下载SVGA动画文件
     * @param filename 文件名
     * @return 文件字节数组
     */
    suspend fun downloadSVGAFile(filename: String): ByteArray? {
        return try {
            val response: Response<ResponseBody> = liveApi.downloadSVGAFile(filename)
            if (response.isSuccessful) {
                response.body()?.bytes()
            } else {
                null
            }
        } catch (e: Exception) {
            null
        }
    }
    
    // ==================== 用户关注方法 ====================
    
    /**
     * 关注用户
     * @param focuseUserid 关注者ID
     * @param focusedUserid 被关注者ID
     * @return 操作结果数据流
     */
    fun focuseUser(focuseUserid: Int, focusedUserid: Int) = flow {
        emit(liveApi.focuseUser(focuseUserid, focusedUserid))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, false, e.message ?: "关注用户失败"))
        }
    
    /**
     * 取消关注用户
     * @param focuseUserid 关注者ID
     * @param focusedUserid 被关注者ID
     * @return 操作结果数据流
     */
    fun unFocuseUser(focuseUserid: Int, focusedUserid: Int) = flow {
        emit(liveApi.unFocuseUser(focuseUserid, focusedUserid))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, false, e.message ?: "取消关注失败"))
        }
    
    /**
     * 获取用户关注列表
     * @param userId 用户ID
     * @return 关注列表数据流
     */
    fun getFocuseListByUserId(userId: Int) = flow {
        emit(liveApi.getFocuseListByUserId(userId))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, emptyList(), e.message ?: "获取关注列表失败"))
        }
    
    /**
     * 检查关注状态
     * @param focuseUserid 关注者ID
     * @param focusedUserid 被关注者ID
     * @return 关注状态数据流
     */
    fun checkFocuseStatus(focuseUserid: Int, focusedUserid: Int) = flow {
        emit(liveApi.checkFocuseStatus(focuseUserid, focusedUserid))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, false, e.message ?: "检查关注状态失败"))
        }
    
    // ==================== 红包系统方法 ====================
    
    /**
     * 获取红包结果
     * @param roomIdBody 房间ID请求体
     * @return 红包结果数据流
     */
    fun getRedPacketResult(roomIdBody: RoomIdBody) = flow {
        emit(liveApi.getRedPacketResult(roomIdBody))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, null, e.message ?: "获取红包结果失败"))
        }
    
    /**
     * 加入红包
     * @param roomIdBody 房间ID请求体
     * @return 操作结果数据流
     */
    fun joinRedPacket(roomIdBody: RoomIdBody) = flow {
        emit(liveApi.joinRedPacket(roomIdBody))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, false, e.message ?: "加入红包失败"))
        }
    
    // ==================== 商品系统方法 ====================
    
    /**
     * 获取直播间商品列表
     * @param roomId 直播间ID
     * @return 商品列表数据流
     */
    fun getLiveRoomGoods(roomId: String) = flow {
        emit(liveApi.getLiveRoomGoods(roomId))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, LiveShopData(0, 0, emptyList(), 0, 0), e.message ?: "获取商品列表失败"))
        }
    
    // ==================== 榜单系统方法 ====================
    
    /**
     *
     * @return 榜单数据流
     */
    fun getOrderHortList(type: String) = flow {
        emit(liveApi.getOrderHortList(type))
    }.flowOn(Dispatchers.IO)
        .catch { e ->
            emit(ResponseEntity(500, emptyList(), e.message ?: "获取榜单失败"))
        }

}